package pkg

import (
	"fmt"
	"sync"
)

// Queue 定义队列结构体
type Queue struct {
	elements []int
	capacity int          // 固定容量
	mu       sync.RWMutex // 读写锁
}

// NewQueue 创建一个新的队列，容量固定为10
func NewQueue() *Queue {
	return &Queue{elements: []int{}, capacity: 20}
}

// Enqueue 入队操作（写操作），如果队列满则自动出栈
func (q *Queue) Enqueue(value int) {
	q.mu.Lock()         // 加锁，进行写操作
	defer q.mu.Unlock() // 在函数结束时解锁

	// 如果队列已满，移除队列的第一个元素
	if len(q.elements) == q.capacity {
		q.elements = q.elements[1:] // 删除队列头部元素
	}
	// 将新元素加入队列
	q.elements = append(q.elements, value)
}

// Dequeue 出队操作（写操作）
func (q *Queue) Dequeue() (int, bool) {
	q.mu.Lock()         // 加锁，进行写操作
	defer q.mu.Unlock() // 在函数结束时解锁

	if len(q.elements) == 0 {
		return 0, false // 返回零值和false表示队列为空
	}

	// 获取队列的第一个元素
	value := q.elements[0]
	// 删除队列中的第一个元素
	q.elements = q.elements[1:]
	return value, true
}

// Clear 清空队列（写操作）
func (q *Queue) Clear() {
	q.mu.Lock()         // 加锁，进行写操作
	defer q.mu.Unlock() // 在函数结束时解锁

	q.elements = []int{}
}

// Size 获取队列的大小（读操作）
func (q *Queue) Size() int {
	q.mu.RLock()         // 加读锁，允许多个协程同时读
	defer q.mu.RUnlock() // 在函数结束时解锁

	return len(q.elements)
}

// Print 打印队列的内容（读操作）
func (q *Queue) Print() {
	q.mu.RLock()         // 加读锁，允许多个协程同时读
	defer q.mu.RUnlock() // 在函数结束时解锁

	fmt.Println(q.elements)
}

// Contains 检查队列是否包含指定元素（读操作）
func (q *Queue) Contains(target int) bool {
	q.mu.RLock()         // 加读锁，允许多个协程同时读
	defer q.mu.RUnlock() // 在函数结束时解锁

	for _, element := range q.elements {
		if element == target {
			return true
		}
	}
	return false
}
